home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Libraries / obi stuff / demo.obi < prev    next >
Text File  |  1986-04-19  |  3KB  |  168 lines
  1. /*
  2.  *   This is the OBJECT class. Its the root of
  3.  *   all objects.
  4.  */
  5.  
  6. /*< class OBJECT >*/
  7.  
  8. /*< super NULL     >*/
  9.  
  10. /*< defines >*/
  11.  
  12. char *malloc();
  13.  
  14. /*< variables class >*/
  15.  
  16. /*< variables instance >*/
  17.  
  18. /*< methods class >*/
  19.  
  20. /*
  21.  * Dynamically create a new object.
  22.  */
  23.  
  24. object Generic *
  25. new()
  26. {
  27.     object Generic *ptr;
  28.     
  29.     /* get memory for the requested object */
  30.     ptr = (object Generic *) malloc(self.size);
  31.     
  32.     /* make the memory into and object */
  33.     objectify => self(ptr);
  34.  
  35.     return ptr;
  36. }
  37.  
  38. /*
  39.  *  Convert memory into a requested Instance object.
  40.  */
  41.  
  42. objectify(ptr)
  43. object Generic *ptr;
  44. {
  45.     ptr->classType = self.classType;
  46.     ptr->superType = self.superType;
  47.     ptr->size = self.size;
  48.     ptr->funcTbl = InstTbl;
  49. }
  50.  
  51.  
  52. /*< methods instance >*/
  53.     /* None. */
  54.  
  55. /*< class TEST >*/
  56.  
  57. /*< super OBJECT >*/
  58.  
  59. /*< defines >*/
  60.  
  61. /*< variables class >*/
  62.  
  63. /*< variables instance
  64.     int value;
  65. >*/
  66.  
  67. /*< methods instance >*/
  68.  
  69. /*
  70.  *  Print the value in the current instance object.
  71.  */
  72. print()
  73. {
  74.     printf(" %d\n", self.value);
  75. }
  76.  
  77. /*
  78.  *  Set the Instance variable value.
  79.  */
  80.  
  81. set(value)
  82. int value;
  83. {
  84.      self.value = value;
  85. }
  86.  
  87. /*
  88.  *  Returns the Instance variable value in the 
  89.  *  current instance object.
  90.  */
  91. view()
  92. {
  93.     return self.value;
  94. }
  95.  
  96. %%%%  /* start C code */
  97.  
  98. main()
  99. {
  100.  
  101.     /*
  102.      * Remember, test1 is a pointer to ans object and
  103.      * therefore has no actual storage allocation for it
  104.      * while test2 has storage for an object already
  105.      * allocated and ready to use.
  106.      */
  107.     object TEST *test1, test2;
  108.  
  109.     /*
  110.      *  The message "new" is sent to the Class object
  111.      *  "TEST" which dynamically creates a new instance
  112.      *  object for the Class TEST (it used the method
  113.      *  "new" from it's superclass OBJECT). Notice the
  114.      *  return value is cast into the desired type.
  115.      */
  116.     test1 = (object TEST *) new => TEST(); 
  117.     
  118.     /*
  119.      *  The message "objectify" sent to the Class object
  120.      *  "TEST" with a pointer to storage large enough to
  121.      *  hold an instance object of TEST Class, turns the 
  122.      *  raw memory into an instance object of type TEST.
  123.      */
  124.     objectify => TEST(&test2);
  125.     
  126.     /*
  127.      *  All references to an object in a message must refer
  128.      *  to the object itself. So in the case where you have
  129.      *  a pointer to an object the pointer must be dereferenced.
  130.      */
  131.     set => *test1(12);
  132.      
  133.     /*
  134.      *  Since this is the object (not a pointer to one)
  135.      *  no dereference is necessary.
  136.      */
  137.     set => test2(13);
  138.       
  139.     printf("test1 "); print => *test1();
  140.     printf("test2 "); print => test2();
  141.     
  142.     /*
  143.      * This is to show what happens when you send a message
  144.      * to an object that it doesn't know about. In this case
  145.      * I will send the Class method message "new" to an instance
  146.      * object.
  147.      */
  148.      new => *test1();
  149. }
  150.  
  151. /*
  152.  *  This function is executed when a message is sent
  153.  *  to an object that it doesn't know about.
  154.  */
  155. doesNotRespond(obj, meth)
  156. object Generic *obj;
  157. int meth;
  158. {
  159.     /* DEBUG is set by the -d flag */
  160. #ifdef DEBUG
  161.     printf("object \"%s\" doesn't respond to \"%s\" commmand\n",
  162. className[obj->classType], methName[meth]);
  163. #else
  164.     printf("object %x does not respond\n", obj->classType);
  165. #endif
  166.     exit();
  167. }
  168.